Instance 0

Class350.getHeapUtilizationStats(){
        final Runtime runtime = Runtime.getRuntime();
        return "Used Memory: " + (runtime.totalMemory() - runtime.freeMemory()) / mb + "M" +
               "\nFree Memory: " + runtime.freeMemory() / mb  + "M" +
               "\nTotal Memory: " + runtime.totalMemory() / mb  + "M" +
               "\nMax Memory: " + runtime.maxMemory() / mb  + "M";
}


Instance 1

Class70.print(String msg){
        Runtime runtime = Runtime.getRuntime();
        System.out.println(String.format("### %s %.2fMB used, %.2fMB free, %.2fMB total, %.2fMB max",
                                         msg,
                                         1.0
                                                 * (runtime.totalMemory() - runtime.freeMemory())
                                                 / mb,
                                         1.0 * runtime.freeMemory() / mb,
                                         1.0 * runtime.totalMemory() / mb,
                                         1.0 * runtime.maxMemory() / mb));
}


Instance 2

Class560.run()#0{
                Runtime runtime = Runtime.getRuntime();
                String s = String.format("free:%s%% %sKB total:%sKB max:%sKB ", runtime.freeMemory() * 100f / runtime.totalMemory(), runtime.freeMemory(), runtime.totalMemory() / 1024,
                        runtime.maxMemory() / 1024);
                Log.d("memory", s);
}


Instance 3

Class530.getCurrentVertex()#1{
        Runtime runtime = Runtime.getRuntime();
        timedLogger.info(
            "read " + recordCount + " records. Memory: " +
            (runtime.totalMemory() / gb) +
            "GB total = " +
            ((runtime.totalMemory() - runtime.freeMemory()) / gb) +
            "GB used + " + (runtime.freeMemory() / gb) +
            "GB free, " + (runtime.maxMemory() / gb) + "GB max");
}


Instance 4

Class190.populateStats(Statistics stats)#2{
    Runtime rt = Runtime.getRuntime();
    long used = rt.totalMemory() - rt.freeMemory();
    stats.addBytes("Max memory", rt.maxMemory());
    stats.addBytes("Used memory", used, critical);
    stats.addBytes("Free memory", rt.freeMemory());
    stats.addBytes("Total memory", rt.totalMemory());
    stats.add("Number of processors", rt.availableProcessors());
}


Instance 5

Class550.doGetSystemProps(ReqState rs)#2{
        Runtime rt = Runtime.getRuntime();
        pw.println("JVM Max Memory:   " + (rt.maxMemory() / 1024) / 1000. + " MB (JVM Maximum Allowable Heap)<br>");
        pw.println("JVM Total Memory: " + (rt.totalMemory() / 1024) / 1000. + " MB (JVM Heap size)<br>");
        pw.println("JVM Free Memory:  " + (rt.freeMemory() / 1024) / 1000. + " MB (Unused part of heap)<br>");
        pw.println("JVM Used Memory:  " + ((rt.totalMemory() - rt.freeMemory()) / 1024) / 1000. + " MB (Currently active memory)<br>");
        pw.println("</html>");
        pw.flush();
}


Instance 6

Class200.reportStatus(final HTTPRequestContext context,final HttpServletRequest request,final HttpServletResponse response)#4{
        final Runtime runtime = Runtime.getRuntime();
        memory.put("totoal", runtime.totalMemory() / mb);
        memory.put("free", runtime.freeMemory() / mb);
        memory.put("used", (runtime.totalMemory() - runtime.freeMemory()) / mb);
        memory.put("max", runtime.maxMemory() / mb);
}


Instance 7

Class380.getStats(){
        Runtime runtime = Runtime.getRuntime();
            + (runtime.totalMemory() - runtime.freeMemory()) / mb);
            + runtime.freeMemory() / mb);
        System.out.println("Total Memory:" + runtime.totalMemory() / mb);
        System.out.println("Max Memory:" + runtime.maxMemory() / mb);
}


Instance 8

Class250.checkMemory(String name,MockDAGAppMaster mockApp)#0{
    Runtime runtime = Runtime.getRuntime();
    runtime.gc();
        + (runtime.totalMemory() - runtime.freeMemory()) / mb);
        + runtime.freeMemory() / mb);
    System.out.println("##### Total Memory:" + runtime.totalMemory() / mb);
    System.out.println("##### Max Memory:" + runtime.maxMemory() / mb);
}


Instance 9

Class250.main(String[] args)#1{
    Runtime r = Runtime.getRuntime();
    r.gc();
    String mem = String.format("Total %dMB, Used %dMB, Free %dMB, Max %dMB", 
        r.totalMemory() / 1048576,
        (r.totalMemory() - r.freeMemory()) / 1048576, 
        r.freeMemory() / 1048576,
        r.maxMemory() / 1048576);
}


Instance 10

Class490.forceGCAction()#1{
            info += decimalFormatter.format(runtime.maxMemory()) + " max, ";
            info += decimalFormatter.format(runtime.totalMemory()) + " total, ";
            info += decimalFormatter.format(runtime.totalMemory()-runtime.freeMemory()) + " used, ";
            info += decimalFormatter.format(runtime.freeMemory()) + " free\n";
            result.setValue(info);
            log.info("GC forced\n"+info);
}


Instance 11

Class490.forceGCAction()#2{
            info += decimalFormatter.format(runtime.maxMemory()) + " max, ";
            info += decimalFormatter.format(runtime.totalMemory()) + " total, ";
            info += decimalFormatter.format(runtime.totalMemory()-runtime.freeMemory()) + " used, ";
            info += decimalFormatter.format(runtime.freeMemory()) + " free\n";
}


Instance 12

Class440.mem()#1{
    System.out.println(String.format("memory max: %.3f total: %.3f free: %.3f used: %.3f (MiB)",
        r.maxMemory() / mib,
        r.totalMemory() / mib,
        r.freeMemory() / mib,
        (r.totalMemory() - r.freeMemory()) / mib));
}


Instance 13

Class680.initialize(Configuration config)#1{
                long expirationTime = configuration.get(DB_CACHE_TIME);
                Preconditions.checkArgument(expirationTime>=0,"Invalid cache expiration time: %s",expirationTime);
                if (expirationTime==0) expirationTime=ETERNAL_CACHE_EXPIRATION;
                double cachesize = configuration.get(DB_CACHE_SIZE);
                Preconditions.checkArgument(cachesize>0.0,"Invalid cache size specified: %s",cachesize);
                if (cachesize<1.0) {
                    //Its a percentage
                    Runtime runtime = Runtime.getRuntime();
                    cacheSizeBytes = (long)((runtime.maxMemory()-(runtime.totalMemory()-runtime.freeMemory())) * cachesize);
                } else {
                    Preconditions.checkArgument(cachesize>1000,"Cache size is too small: %s",cachesize);
                    cacheSizeBytes = (long)cachesize;
                }
                log.info("Configuring total store cache size: {}",cacheSizeBytes);
                long cleanWaitTime = configuration.get(DB_CACHE_CLEAN_WAIT);
}


Instance 14

Class310.monitor15()#2{
      Runtime rt = Runtime.getRuntime();
      log.log( "Thread state: elapsed=" + elapsed + ",cpu=" + total_diffs + ",max=" + thread_name + "(" + biggest_diff + "/" + percent + "%),mem:max=" + (rt.maxMemory()/1024)+",tot=" + (rt.totalMemory()/1024) +",free=" + (rt.freeMemory()/1024));
      if ( biggest_diff > time_available/4 ){
        
        info = bean.getThreadInfo( ids[biggest_index ], 255 );
        
        if ( info == null ){
          
          log.log( "    no info for max thread" );
          
        }else{
          
          StackTraceElement[] elts = info.getStackTrace();
          StringBuilder str = new StringBuilder(elts.length * 20);
          
          str.append("    ");
          for (int i=0;i<elts.length;i++){
            if(i != 0)
              str.append(", ");
            str.append(elts[i]);
          }
          
          log.log( str.toString() );
        }
      }
}


Instance 15

Class10.mouseClicked(MouseEvent e)#1{
            Runtime currR = Runtime.getRuntime();
            long freeM = currR.freeMemory();
            long totalM = currR.totalMemory();
            long maxM = currR.maxMemory();
            logPanel.
            logMessage("[KnowledgeFlow] Memory (free/total/max.) in bytes: " 
                + String.format("%,d", freeM) + " / " 
                + String.format("%,d", totalM) + " / " 
                + String.format("%,d", maxM));
            logPanel.statusMessage("[KnowledgeFlow]|Memory (free/total/max.) in bytes: " 
                + String.format("%,d", freeM) + " / " 
                + String.format("%,d", totalM) + " / " 
                + String.format("%,d", maxM)); 
}


Instance 16

Class310.renderSettings(EntryManager entryManager,StringBuilder sb)#1{
        final Runtime rt = Runtime.getRuntime();
        sb.append(String.format("-- Memory free: %4.2fMB total: %4.2fMB max: %4.2fMB\n",
                rt.freeMemory() / 1024 / 1024.0, rt.totalMemory() / 1024 / 1024.0, rt.maxMemory() / 1024 / 1024.0));
        sb.append("-- Model: " + Build.MODEL + "\n");
}


Instance 17

Class490.run()#25{
              Runtime rt = Runtime.getRuntime();
              long freeMemory = rt.freeMemory();
              long totalMemory = rt.totalMemory();
              long maxMemory = rt.maxMemory();
              if (FORCE_GC_MEMORY_EVENTS ||
                  freeMemory / (totalMemory * 1.0) < GC_MEMORY_THRESHOLD) {
                forceBatchExpiration = !this.batchExpirationInProgress &&
                       this.expiredTombstones.size() > (EXPIRED_TOMBSTONE_LIMIT / 4);
                if (forceBatchExpiration) {
                  if (logger.isDebugEnabled()) {
                    logger.debug("forcing batch expiration due to low memory conditions");
                  }
                }
                // forcing expiration of tombstones that have not timed out can cause inconsistencies
                // too easily
  //              if (this.batchMode) {
  //                forceExpirationCount = EXPIRED_TOMBSTONE_LIMIT - this.expiredTombstones.size();
  //              } else {
  //                forceExpirationCount = EXPIRED_TOMBSTONE_LIMIT;
  //              }
  //              maximumSleepTime = 1000;
              }
}


Instance 18

Class80.uncaughtException(Thread t,Throwable e)#3{
      Runtime rt = Runtime.getRuntime();
      message.append(String.format("-- Memory free: %4.2fMB total: %4.2fMB max: %4.2fMB",
          rt.freeMemory() / 1024 / 1024.0, 
          rt.totalMemory() / 1024 / 1024.0,
          rt.maxMemory() / 1024 / 1024.0));
}


Instance 19

Class120.automatic()#0{
      Runtime rt = Runtime.getRuntime();
      final long max = rt.maxMemory(); // max allocated
      final long total = rt.totalMemory(); // currently allocated
      final long free = rt.freeMemory(); // unused portion of currently allocated
      if (sortBufferByteSize <  minBufferSizeBytes
          || totalAvailableBytes > 10 * minBufferSizeBytes) { // lets see if we need/should to grow the heap 
        if (totalAvailableBytes/2 > minBufferSizeBytes){ // there is enough mem for a reasonable buffer
          sortBufferByteSize = totalAvailableBytes/2; // grow the heap
        } else {
          //heap seems smallish lets be conservative fall back to the free/2 
          sortBufferByteSize = Math.max(ABSOLUTE_MIN_SORT_BUFFER_SIZE, sortBufferByteSize);
        }
      }
}


Instance 20

Class160.handleMethodGET(URI uri,HTTPRequest request,ToadletContext ctx)#71{
    Runtime rt = Runtime.getRuntime();
    long freeMemory = rt.freeMemory();
    long totalMemory = rt.totalMemory();
    long maxMemory = rt.maxMemory();
    int availableCpus = rt.availableProcessors();
}


Instance 21

Class610.removeEldestEntry(Map.Entry<Key,Value> eldest)#1{
          Runtime runtime = Runtime.getRuntime();
          long freeMem = runtime.freeMemory() / 1024 / 1024;
          long maxMem = runtime.maxMemory() / 1024 / 1024;
          long totalMem = runtime.totalMemory() / 1024 / 1024;
          LOG.info( "mem on flush (mb), free: " + freeMem + ", total: " + totalMem + ", max: " + maxMem );
          float percent = (float) totalMem / (float) maxMem;
          if( percent < 0.80F )
            LOG.info( "total mem is {}% of max mem, to better utilize unused memory consider increasing the cache size", (int) ( percent * 100.0F ) );
}


Instance 22

Class90.run()#1{
                    Runtime runtime = Runtime.getRuntime();
                    long dalvikMax = runtime.maxMemory();
                    long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
                    if (dalvikUsed > ((3*dalvikMax)/4)) {
                        if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
                                + " total=" + (runtime.totalMemory()/1024)
                                + " used=" + (dalvikUsed/1024));
                        mSomeActivitiesChanged = false;
                        try {
                            mgr.releaseSomeActivities(mAppThread);
                        } catch (RemoteException e) {
                        }
                    }
}


Instance 23

Class490.initOsmAndRoutingConfig(Builder config,final RouteCalculationParams params,OsmandSettings settings,GeneralRouter generalRouter)#0{
    Runtime rt = Runtime.getRuntime();
    int memoryLimit = (int) (0.95 * ((rt.maxMemory() - rt.totalMemory()) + rt.freeMemory()) / mb);
}


Instance 24

Class210.run()#2{
    Runtime r = Runtime.getRuntime();
    long totalMemory = r.totalMemory();
    long freeMemory = r.freeMemory();
    long maxMemory = r.maxMemory();
    Logger.normal(this, "Memory in use: "+SizeUtil.formatSize((totalMemory-freeMemory)));
    if (totalMemory == maxMemory || maxMemory == Long.MAX_VALUE) {
      // jvm have allocated maximum memory
      // totalMemory never decrease, so check it only for once
      if (avgFreeMemory == null)
        avgFreeMemory = new SimpleRunningAverage(3, freeMemory);
      else
        avgFreeMemory.report(freeMemory);
      
      if (avgFreeMemory.countReports() >= 3 && avgFreeMemory.currentValue() < 4 * 1024 * 1024) {//  average free memory < 4 MB
        Logger.normal(this, "Reached threshold, checking for low memory ...");
        System.gc();
        System.runFinalization();

        try {
          Thread.sleep(10); // Force a context switch, finalization need a CS to complete
        } catch (InterruptedException e) {
        }

        freeMemory = r.freeMemory();
        avgFreeMemory.report(freeMemory);
      }
    }
}


Instance 25

Class130.reportMemoryStats(final String stage)#0{
        final Runtime runtime = Runtime.getRuntime();
        log.info(stage + " freeMemory: " + runtime.freeMemory() + "; totalMemory: " + runtime.totalMemory() +
                "; maxMemory: " + runtime.maxMemory());
}


Instance 26

Class70.drawJVMStatsBox(HTMLNode jvmStatsInfobox,boolean advancedModeEnabled)#2{
    Runtime rt = Runtime.getRuntime();
    long freeMemory = rt.freeMemory();
    long totalMemory = rt.totalMemory();
    long maxMemory = rt.maxMemory();
    int availableCpus = rt.availableProcessors();
}


Instance 27

Class190.logProgress(Object info)#0{
      Runtime runtime = Runtime.getRuntime();
      logger.debug("Step: " + info + " memory: free / total / max MB " + runtime.freeMemory() / (1000 * 1000) + " / " + runtime.totalMemory() / (1000 * 1000) + " / " + runtime.maxMemory() / (1000 * 1000));
}


Instance 28

Class130.describeMemoryUsage(){
        Runtime runtime = Runtime.getRuntime();
        long free = runtime.freeMemory();
        return String.format(
            "%sM used, %sM free, %sM max",
            (runtime.totalMemory() - free) / 1000000,
            free / 1000000,
            runtime.maxMemory() / 1000000
        );
}


Instance 29

Class20.isToBig(int contentLength)#0{
    Runtime rt = Runtime.getRuntime();
    long av = rt.maxMemory()-rt.totalMemory()+rt.freeMemory();
}


Instance 30

Class330.executeOnSlave()#1{
      Runtime runtime = Runtime.getRuntime();
      slaveState.putPersistent(INITIAL_FREE_MEMORY, runtime.freeMemory() + runtime.maxMemory() - runtime.totalMemory());
}


Instance 31

Class40.generateEvidence(PrintWriter _writer)#1{
      Runtime rt = Runtime.getRuntime();
      writer.println( "max=" + rt.maxMemory() + ",total=" + rt.totalMemory() + ",free=" + rt.freeMemory());
      writer.exdent();
}


Instance 32

Class240.testMemoryLimit(){
    Runtime runtime = Runtime.getRuntime(); 
    return (runtime.maxMemory() - (runtime.totalMemory() - runtime.freeMemory())) < MIN_FREE_MEMORY_BYTES;
}


Instance 33

Class350.showMem(String where){
    Runtime runtime = Runtime.getRuntime();
    System.out.println(where+ " memory free = " + runtime.freeMemory() * .001 * .001 +
        " total= " + runtime.totalMemory() * .001 * .001 +
        " max= " + runtime.maxMemory() * .001 * .001 +
}


Instance 34

Class650.processLine(BufferedReader reader)#97{
    Runtime rt = Runtime.getRuntime();
    float freeMemory = rt.freeMemory();
    float totalMemory = rt.totalMemory();
    float maxMemory = rt.maxMemory();
}


Instance 35

Class440.run()#1{
            Runtime runtime = Runtime.getRuntime();
            long free = runtime.freeMemory();
            long total = runtime.totalMemory();
            long max = runtime.maxMemory();
}


Instance 36

Class680.test(String[] args)#2{
        Runtime rt = Runtime.getRuntime();
        long freeMin = rt.freeMemory();
        System.out.println("DEBUG: Free1: "+freeMin+", total: "+rt.totalMemory()+", max: "+rt.maxMemory());
}


Instance 37

Class410.getAvailableMemory(){
        Runtime runtime = Runtime.getRuntime();
        long maxMemory = runtime.maxMemory();
        long allocatedMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
}


Instance 38

Class720.getAvailableMemory(){
    final Runtime r = Runtime.getRuntime();
    final long usedMem = r.totalMemory() - r.freeMemory();
    return r.maxMemory() - usedMem;
}


Instance 39

Class320.getAvaibleRAMMeg(){
    Runtime runtime = Runtime.getRuntime();
    long used = (runtime.totalMemory() - runtime.freeMemory()) / MB;
    return runtime.maxMemory() / MB - used;
}


Instance 40

Class230.displayMemoryUsage()#0{
        Runtime runtime = Runtime.getRuntime();
        long freeMemory = runtime.freeMemory();
        long totalMemory = runtime.totalMemory();
        String memoryStatus = usedInMegabytes + "M / " + totalInMegabytes + "M / " + (runtime.maxMemory() / mega) + "M";
        if (usedInMegabytes <= lastUsage - MEMORY_THRESHOLD || usedInMegabytes >= lastUsage + MEMORY_THRESHOLD) {
            String threadName = Thread.currentThread().getName();
            System.out.println("%%% [" + threadName + "] Memory usage: " + memoryStatus);
            lastUsage = usedInMegabytes;
        }
}


Instance 41

Class660.execute(final SQLSession session,final String command,final String parameters)#0{
        final Runtime rt = Runtime.getRuntime();
        final double totalMemory = rt.totalMemory() / (double) ONE_KILOBYTE;
        final double freeMemory = rt.freeMemory() / (double) ONE_KILOBYTE;
        final double maxMemory = rt.maxMemory() / (double) ONE_KILOBYTE;
        info.put("Max memory [KB]", Formatter.formatNumber(maxMemory, 2));
        info.put("Allocated memory [KB]", Formatter.formatNumber(totalMemory, 2));
        info.put("Free memory [KB]", Formatter.formatNumber(freeMemory, 2));
        info.put("Used memory [KB]", Formatter.formatNumber(memoryUsed, 2));
        info.put("Diff. of used memory (now-before) [KB]", Formatter.formatNumber(diffMemory, 2));
        renderInfo(info);
}


Instance 42

Class720.run()#2{
                Runtime runtime = Runtime.getRuntime();
                long maxMemory = runtime.maxMemory();
                long allocatedMemory = runtime.totalMemory();
                long freeMemory = runtime.freeMemory();
}


Instance 43

Class310.paintComponent(final Graphics g)#7{
      final Runtime rt = Runtime.getRuntime();
      final long maxMem = rt.maxMemory();
      final long allocatedMem = rt.totalMemory();
      final long unusedMem = rt.freeMemory();
}


Instance 44

Class200.endPackage()#0{
      final Runtime runtime= Runtime.getRuntime();
      final long maxMemory= runtime.maxMemory();
      final long allocatedMemory= runtime.totalMemory();
      final long freeMemory= runtime.freeMemory();
}


Instance 45

Class220.getSizeOfFreeMemory()#0{
    Runtime r = Runtime.getRuntime();
    long max = r.maxMemory();
    long total = r.totalMemory();
    long free = r.freeMemory();
}


Instance 46

Class220.getCpuMemStats(){
    Runtime rt = Runtime.getRuntime();
    long totalMem = rt.totalMemory();
    long maxMem = rt.maxMemory();
    long freeMem = rt.freeMemory();
    return String.format(msg, totalMem / megs, usedMem / megs, maxMem / megs);
}


Instance 47

Class160.possibleOutOfMemory(int neededMemory){
    Runtime runtime = Runtime.getRuntime();
    long maxMemory = runtime.maxMemory();
    long realFreeMemory = runtime.freeMemory() + (maxMemory - runtime.totalMemory());
}


Instance 48

Class530.clearCacheIfLowOnMem()#0{
        Runtime r = Runtime.getRuntime();
        long max = r.maxMemory();
        if(max == Long.MAX_VALUE)
            return;
        double free = r.freeMemory();
        double total = r.totalMemory();
}


Instance 49

Class300.checkFreeMem()#0{
            Runtime r = Runtime.getRuntime();
            long max = r.maxMemory();
            if(max == Long.MAX_VALUE)
                return;
            double free = r.freeMemory();
            double total = r.totalMemory();
}


Instance 50

Class590.notifyWriteSpillBegin(Spillable spillable,int spillSize,String spillReason){
      int numFiles = spillable.spillCount();
      if( numFiles % 10 == 0 )
        {
        LOG.info( "spilling grouping: {}, num times: {}, with reason: {}",
          new Object[]{spillable.getGrouping().print(), numFiles + 1, spillReason} );

        Runtime runtime = Runtime.getRuntime();
        long freeMem = runtime.freeMemory() / 1024 / 1024;
        long maxMem = runtime.maxMemory() / 1024 / 1024;
        long totalMem = runtime.totalMemory() / 1024 / 1024;

        LOG.info( "mem on spill (mb), free: " + freeMem + ", total: " + totalMem + ", max: " + maxMem );
        }
      LOG.info( "spilling {} tuples in list to file number {}", spillSize, numFiles + 1 );
      flowProcess.increment( Spill.Num_Tuples_Spilled, spillSize );
}


Instance 51

Class660.getMemoryUsage()#2{
        Runtime rt = Runtime.getRuntime();
        long max = rt.maxMemory();
        long free = rt.freeMemory();
        long total = rt.totalMemory();
}


Instance 52

Class450.test()#0{
        final Runtime runtime = Runtime.getRuntime();
        System.out.println("maxMemory = " + runtime.maxMemory());
        System.out.println("freeMemory = " + runtime.freeMemory());
        System.out.println("totalMemory = " + runtime.totalMemory());
}


Instance 53

Class210.addMemoryMetrics(List<MetricDatum> targetList,Set<MachineMetric> customSet){
        Runtime rt = Runtime.getRuntime();
        long totalMem = rt.totalMemory();
        long freeMem = rt.freeMemory();
        long spareMem = rt.maxMemory() - usedMem;
        List<Long> values = Arrays.asList(totalMem, freeMem, usedMem, spareMem);
        MetricValues metricValues = memoryMetricValues(customSet, values);
        addMetrics(targetList, metricValues, StandardUnit.Bytes);
}


Instance 54

Class120.memory()#1{
        Runtime rt = Runtime.getRuntime(); 
        long maxMemory=rt.maxMemory();
        long freeMemory=rt.freeMemory();
        long totalMemory=rt.totalMemory();
        response = ImmutableMap.of(
            "max_allocable_memory",maxMemory,
            "current_allocate_memory", totalMemory,
            "used_memory_in_the_allocate_memory",totalMemory - freeMemory,
            "free_memory_in_the_allocated_memory", freeMemory
            );
}


Instance 55

Class430.display()#0{
    final Runtime r = Runtime.getRuntime();
    final long mMax = r.maxMemory();
    final long mFree = r.freeMemory();
    final long mTotal = r.totalMemory();
}


Instance 56

Class470.generateReport(long now,boolean reset)#9{
        Runtime rt = Runtime.getRuntime();
        long total = rt.totalMemory(), max = rt.maxMemory();
        long used = (total - rt.freeMemory());
}


Instance 57

Class330.getAbout()#1{
  final Runtime runtime = getRuntime();  
  final long freeMemory = runtime.freeMemory();
  vMProperties.setTotalMemory(runtime.totalMemory());
  vMProperties.setUsedMemory(runtime.totalMemory() - freeMemory);
  vMProperties.setFreeMemory(freeMemory);
  vMProperties.setMaxMemory(runtime.maxMemory());
}


Instance 58

Class690.printMemory(){
    Runtime rt = Runtime.getRuntime();
    long total = rt.totalMemory();
    long free = rt.freeMemory();
    long max = rt.maxMemory();
    System.out.println(String.format("total=%dk, free=%dk, max=%dk, use=%dk", total/1024, free/1024, max/1024, (total-free)/1024));
}


Instance 59

Class120.getRow(String charset)#4{
    Runtime rt = Runtime.getRuntime();
    long total = rt.totalMemory();
    long max = rt.maxMemory();
    long used = (total - rt.freeMemory());
}


Instance 60

Class150.redraw(GL2 gl)#7{
      Runtime rt = Runtime.getRuntime();
      long free = rt.freeMemory(), total = rt.totalMemory();
      FastText.aprintf(g, new Coord(10, y -= 15), 0, 1, "Mem: %,011d/%,011d/%,011d/%,011d", free, total - free, total, rt.maxMemory());
}


Instance 61

Class170.getMemoryState()#0{
    Runtime rt = Runtime.getRuntime();
    return new MemoryState( rt.freeMemory(), rt.totalMemory(), rt.maxMemory() );
}


Instance 62

Class620.exportVolatileFieldSet()#29{
    Runtime rt = Runtime.getRuntime();
    float freeMemory = rt.freeMemory();
    float totalMemory = rt.totalMemory();
    float maxMemory = rt.maxMemory();
}


Instance 63

Class140.right(HttpServletRequest request,ModelMap model)#0{
    Runtime runtime = Runtime.getRuntime();
    long freeMemoery = runtime.freeMemory();
    long totalMemory = runtime.totalMemory();
    long maxMemory = runtime.maxMemory();
    model.addAttribute("user", user);
    model.addAttribute("flowMap", cmsStatisticSvc.getWelcomeSiteFlowData(site.getId()));
}


Instance 64

Class410.actionPerformed(ActionEvent ee)#0{
      Runtime currR = Runtime.getRuntime();
      long freeM = currR.freeMemory();
      long totalM = currR.totalMemory();
      long maxM = currR.maxMemory();
      logMessage("Memory (free/total/max.) in bytes: " + printLong(freeM) + " / " + printLong(totalM) + " / " + printLong(maxM));
      statusMessage("Memory (free/total/max.) in bytes: " + printLong(freeM) + " / " + printLong(totalM) + " / " + printLong(maxM));
}


Instance 65

Class110.logMemoryStatistics(){
    Runtime runtime = Runtime.getRuntime();
    long freeBytes = runtime.freeMemory();
    long maxBytes = runtime.maxMemory();
    long totalBytes = runtime.totalMemory();
    log.info("Memory (bytes): {} used, {} heap, {} max", new Object[] { usedByt
}


Instance 66

Class690.SysInfo(){
        final Runtime runtime = Runtime.getRuntime();
        freeMB = runtime.freeMemory()/MB;
        totalMB = runtime.totalMemory()/MB;
        maxMB = runtime.maxMemory()/MB;
}


Instance 67

Class450.run()#1{
                    Runtime runtime = Runtime.getRuntime();
                    long free = runtime.freeMemory();
                    long total = runtime.totalMemory();
                    long max = runtime.maxMemory();
}


Instance 68

Class600.main2(String[] args)#0{
    Runtime lRuntime = Runtime.getRuntime();
    System.out.println("--------------Free Momery:" + lRuntime.freeMemory() + "K");
    System.out.println("--------------Max Momery:" + lRuntime.maxMemory() + "K");
    System.out.println("--------------Total Momery:" + lRuntime.totalMemory() + "K");
    System.out.println("---------------Available Processors :" + lRuntime.availableProcessors());
}


Instance 69

Class550.writeReport(final PrintWriter writer,ExceptionAnalysis analysis)#3{
        Runtime runtime = Runtime.getRuntime();
        writer.printf("%n%nMemory:%n  %,15d bytes free%n  %,15d bytes total%n  %,15d bytes max%n",
                runtime.freeMemory(),
                runtime.totalMemory(),
                runtime.maxMemory());
}


Instance 70

Class550.paintComponent(final Graphics g)#0{
    final Runtime rt = Runtime.getRuntime();
    final long max = rt.maxMemory();
    final long total = rt.totalMemory();
    final long used = total - rt.freeMemory();
}


Instance 71

Class60.logMemoryUsage(){
        Runtime runtime = Runtime.getRuntime();
        long maxMemoryBytes = runtime.maxMemory();
        long freeMemoryBytes = runtime.freeMemory();
        long totalMemoryBytes = runtime.totalMemory();
        long maxMemoryMB = toMB(maxMemoryBytes);
        logger.info("Memory Usage: Using %d MB of %d MB (%.2f%%) [%d MB free]", usedMemoryMB, maxMemoryMB, percentageUsed, availableMemoryMB);
}


Instance 72

Class160.a(){
        Runtime runtime = Runtime.getRuntime();
        long i = runtime.maxMemory();
        long j = runtime.totalMemory();
        long k = runtime.freeMemory();
}


Instance 73

Class450.dumpMemStats()#1{
    Runtime runtime = Runtime.getRuntime();
    final long maxMemory = runtime.maxMemory();
    final long allocatedMemory = runtime.totalMemory();
    final long freeMemory = runtime.freeMemory();
}


Instance 74

Class600.info(){
    final Runtime rt = Runtime.getRuntime();
    final long max = rt.maxMemory();
    final long total = rt.totalMemory();
    final long used = total - rt.freeMemory();
    return TOTAL_MEM_C + Performance.format(max, true) + NL
        + RESERVED_MEM_C + Performance.format(total, true) + NL + MEMUSED_C
        + Performance.format(used, true) + NL + NL + H_USED_MEM;
}


Instance 75

Class500.getAvailableMemoryFraction()#0{
        Runtime runtime = Runtime.getRuntime();
        long maxMemory = runtime.maxMemory();
        long allocatedMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
}


Instance 76

Class680.checkFreeMem()#2{
            Runtime r = Runtime.getRuntime();
            long max = r.maxMemory();
            if(max == Long.MAX_VALUE)
                return;
            double free = r.freeMemory();
            double total = r.totalMemory();
}


Instance 77

Class270.put(Key key,Value value)#1{
      Runtime runtime = Runtime.getRuntime();
      long freeMem = runtime.freeMemory() / 1024 / 1024;
      long maxMem = runtime.maxMemory() / 1024 / 1024;
      long totalMem = runtime.totalMemory() / 1024 / 1024;
      LOG.info( "mem on flush (mb), free: " + freeMem + ", total: " + totalMem + ", max: " + maxMem );
}


Instance 78

Class320.memoryInfo(){
        Runtime runtime = Runtime.getRuntime();
        return new MemoryInfo(runtime.totalMemory(), runtime.freeMemory(), runtime.maxMemory());
}


Instance 79

Class270.getDisplayStats(Display d)#8{
        Runtime rt = Runtime.getRuntime();
        long tm = rt.totalMemory() / (2<<20);
        long fm = rt.freeMemory() / (2<<20);
        long mm = rt.maxMemory() / (2<<20);
}


Instance 80

Class690.getHeapMemoryUsage(){
  Runtime runtime = Runtime.getRuntime();
  long totalMem = runtime.totalMemory();
  return new MemoryUsage(-1L, totalMem - runtime.freeMemory(), totalMem,
          runtime.maxMemory());
}


Instance 81

Class210.printResources(PrintWriter response)#1{
    response.append("Total Memory: " + (rt.totalMemory() >> 20) + "MB<br>\n");
    response.append("Used Memory: " + ((rt.totalMemory() - rt.freeMemory()) >> 20) + "MB<br>\n");
    response.append("Max Memory: " + (rt.maxMemory() >> 20) + "MB<br>\n");
}


Instance 82

Class540.getMemoryStatus(){
        Runtime runtime = Runtime.getRuntime();
        long total = runtime.totalMemory();
        long used = total - runtime.freeMemory();
        long max = runtime.maxMemory();
        return formatMemory( used ) + "/" + formatMemory( total ) + " (Max: " + formatMemory( max ) + ")";
}


Instance 83

Class150.run()#4{
      final Runtime run = Runtime.getRuntime();
      hb.set_free_mem  (run. freeMemory());
      hb.set_max_mem   (run.  maxMemory());
      hb.set_tot_mem   (run.totalMemory());
}


Instance 84

Class510.getRow(String charset)#5{
        Runtime rt = Runtime.getRuntime();
        long total = rt.totalMemory();
        long max = rt.maxMemory();
        long used = (total - rt.freeMemory());
}


Instance 85

Class20.generateReport(String type,long now,boolean reset)#9{
            Runtime rt = Runtime.getRuntime();
            long total = rt.totalMemory(), max = rt.maxMemory();
            long used = (total - rt.freeMemory());
}


Instance 86

Class240.getSizeOfFreeHeapMemory()#2{
    Runtime r = Runtime.getRuntime();
    long maxMemory = r.maxMemory();
    if (maxMemory == Long.MAX_VALUE) {
      // amount of free memory unknown
      try {
        // workaround for Oracle JDK
        OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
        Class<?> clazz = Class.forName("com.sun.management.OperatingSystemMXBean");
        Method method = clazz.getMethod("getTotalPhysicalMemorySize");
        maxMemory = (Long) method.invoke(operatingSystemMXBean) / 4;
      } catch (Throwable e) {
        throw new RuntimeException("Could not determine the amount of free memory.\n" +
            "Please set the maximum memory for the JVM, e.g. -Xmx512M for 512 megabytes.");
      }
    }
    return maxMemory - r.totalMemory() + r.freeMemory();
}


Instance 87

Class650.Report(Throwable t)#1{
  Runtime rt = Runtime.getRuntime();
  props.put("mem.free", rt.freeMemory());
  props.put("mem.total", rt.totalMemory());
  props.put("mem.max", rt.maxMemory());
}


Instance 88

Class500.getInfo(Integer div)#0{
  Runtime myRun = Runtime.getRuntime();    
  buff.append("max:"+ (myRun.maxMemory()/div));
  buff.append(",total:"+ (myRun.totalMemory()/div));
  buff.append(",free:"+ (myRun.freeMemory()/div));
  return buff.toString();
}


Instance 89

Class80.availableMemory(){
    Runtime rt = Runtime.getRuntime();
    return rt.maxMemory() - rt.totalMemory() + rt.freeMemory();
}


Instance 90

Class480.printMemoryFootprint(){
      Runtime run = Runtime.getRuntime();
      String memoryInfo = "Memory - free: " + kbString(run.freeMemory()) + " - max:" + kbString(run.maxMemory()) + "- total:" + kbString(run.totalMemory());
}


Instance 91

Class500.checkMemoryReleased()#2{
         Runtime runtime = Runtime.getRuntime();
         currentFreeMemory = runtime.freeMemory() + runtime.maxMemory() - runtime.totalMemory();
}


Instance 92

Class20.executeOnSlave()#1{
         Runtime runtime = Runtime.getRuntime();
         long availableMemory = runtime.freeMemory() + runtime.maxMemory() - runtime.totalMemory();
}


Instance 93

Class210.generateAlternativeSeed()#1{
            Runtime runtime = Runtime.getRuntime();
            out.writeLong(runtime.freeMemory());
            out.writeLong(runtime.maxMemory());
            out.writeLong(runtime.totalMemory());
}


Instance 94

Class590.setPolicyDirectoryPath(String dbHome)#1{
            Runtime runtime = Runtime.getRuntime();
            logger.debug("Total memory: " + runtime.totalMemory() / 1024);
            logger.debug("Free memory: " + runtime.freeMemory() / 1024);
            logger.debug("Max memory: " + runtime.maxMemory() / 1024);
}


Instance 95

Class310.init()#2{
            Runtime runtime = Runtime.getRuntime();
            log.debug("Total memory: " + runtime.totalMemory() / 1024);
            log.debug("Free memory: " + runtime.freeMemory() / 1024);
            log.debug("Max memory: " + runtime.maxMemory() / 1024);
}


Instance 96

Class380.run()#0{
              Runtime runtime = Runtime.getRuntime();
              long maxMemory = mb(runtime.maxMemory());
              long allocatedMemory = mb(runtime.totalMemory());
              long freeMemory = mb(runtime.freeMemory());
}


Instance 97

Class210.run()#0{
                Runtime runtime = Runtime.getRuntime();
                long maxMemory = mb(runtime.maxMemory());
                long allocatedMemory = mb(runtime.totalMemory());
                long freeMemory = mb(runtime.freeMemory());
}


Instance 98

Class690.BenchmarkCreator(String label)#0{
    Runtime runtime = Runtime.getRuntime();
    properties.setProperty("java.memory.free",
        String.valueOf(runtime.freeMemory()));
    properties.setProperty("java.memory.total",
        String.valueOf(runtime.totalMemory()));
    properties.setProperty("java.memory.max",
        String.valueOf(runtime.maxMemory()));
    properties.setProperty("java.processors.available",
        String.valueOf(runtime.availableProcessors()));
}


Instance 99

Class710.doAction(DebugController.Event e){
        Runtime runt = Runtime.getRuntime();
        e.pw.println(" freeMemory= " + scale * runt.freeMemory() + " Mb");
        e.pw.println(" totalMemory= " + scale * runt.totalMemory() + " Mb");
        e.pw.println(" maxMemory= " + scale * runt.maxMemory() + " Mb");
        e.pw.println(" availableProcessors= " + runt.availableProcessors());
        e.pw.println();
        ServletUtil.showThreads(e.pw);
}


Instance 100

Class530.list()#1{
        Runtime runtime = Runtime.getRuntime();
        put(l, "os.memory.free",
               Long.toString(runtime.freeMemory() / mb) + "MB");
        put(l, "os.memory.max",
               Long.toString(runtime.maxMemory() / mb) + "MB");
        put(l, "os.memory.total",
               Long.toString(runtime.totalMemory() / mb) + "MB");
}


Instance 101

Class420.getStats()#3{
        Runtime runtime = Runtime.getRuntime();
        stats.put("jvm_free_memory", String.valueOf(runtime.freeMemory()));
        stats.put("jvm_max_memory", String.valueOf(runtime.maxMemory()));
        stats.put("jvm_total_memory", String.valueOf(runtime.totalMemory()));
}


Instance 102

Class620.reload(PageContext pc)#11{
      Runtime rt = Runtime.getRuntime();
      java.setEL(FREE_MEMORY,new Double(rt.freeMemory()));
      java.setEL(TOTAL_MEMORY,new Double(rt.totalMemory()));
      java.setEL(MAX_MEMORY,new Double(rt.maxMemory()));
}


Instance 103

Class100.SeededSecureRandom()#2{
            Runtime runtime = Runtime.getRuntime();
            setSeed(runtime.freeMemory());
            setSeed(runtime.maxMemory());
            setSeed(runtime.totalMemory());
}


Instance 104

Class560.Memory(Runtime runtime){
      maxMemory = runtime.maxMemory();
      totalMemory = runtime.totalMemory();
      freeMemory = runtime.freeMemory();
}


Instance 105

Class420.reportMemory()#0{
        long maxMemory = runtime.maxMemory();
        long allocatedMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        sb.append("allocated memory: " + format.format(allocatedMemory / (1024*1024)) + "M\n");
        sb.append("--------------\n");          
        sb.append("[ Xmx: " + format.format(maxMemory / (1024*1024)) + "M ]\n");
        return sb.toString();
}


Instance 106

Class680.test(String[] args)#16{
        freeMin = rt.freeMemory();
        System.out.println("DEBUG: Free2: "+freeMin+", total: "+rt.totalMemory()+", max: "+rt.maxMemory());
}


Instance 107

Class430.dispatchLoop()#1{
      long currentMemorySize = rt.totalMemory();
      long memoryUsed = currentMemorySize - rt.freeMemory();
      long maxMemory = rt.maxMemory();
      while (memoryUsed > maxMemory * PUSHBACK_THRESHOLD_RATIO) {
        if (lastPushbackLog < (lastPushbackLog = System.currentTimeMillis()) - 60 * 1000) {
          LOG.warn(
              "In pushback, not accepting new work. Using {}MB / {}MB ({}MB currently used by JVM)",
              memoryUsed >> 20, maxMemory >> 20, currentMemorySize >> 20);
          System.gc();
        }
        sleep(10);
      }
}


Instance 108

Class220.run()#2{
            long maxMemory = runtime.maxMemory();
            long allocatedMemory = runtime.totalMemory();
            long freeMemory = runtime.freeMemory();
}


Instance 109

Class690.cleanMemory(String message,int count)#0{
      runtime.runFinalization();
      runtime.gc();
      allocatedMemory = runtime.totalMemory();
      freeMemory = runtime.freeMemory();
      if (after == allocatedMemory - freeMemory) break;
    long maxMemory = runtime.maxMemory();
    if ((after - before) > (1024 * 1024)) logger.debug(message + ": used "
        + dFormat.format((double) (after - before) / (double) (1024 * 1024)) + " MB for "
        + dFormat.format(count) + " objects, " + Math.round((double) (after - before) / (double) count)
        + " Bytes per object, " + (timestampAfter - timestampBefore) + " milliseconds, "
        + dFormat.format(Math.round((double) count * 1000 / (double) (timestampAfter - timestampBefore + 1)))
        + " objects per second");
    else
      logger.debug(message
          + ": used "
          + dFormat.format((double) (after - before) / (double) 1024)
          + " KB for "
          + dFormat.format(count)
          + " objects, "
          + Math.round((double) (after - before) / (double) count)
          + " Bytes per object, "
          + (timestampAfter - timestampBefore)
          + " milliseconds, "
          + dFormat.format(Math
              .round((double) count * 1000 / (double) (timestampAfter - timestampBefore + 1)))
          + " objects per second");
}


Instance 110

Class470.dumpEnvironment()#1{
        buffer.append(String.format(
            "OrientDB Memory profiler: HEAP=%s of %s - DISKCACHE (%s dbs)=%s of %s - OS=%s of %s - FS=%s of %s",
            OFileUtils.getSizeAsString(runtime.totalMemory() - runtime.freeMemory()),
            OFileUtils.getSizeAsString(runtime.maxMemory()), stgs, OFileUtils.getSizeAsString(diskCacheUsed),
            OFileUtils.getSizeAsString(diskCacheTotal), OFileUtils.getSizeAsString(osUsedMem),
            OFileUtils.getSizeAsString(osTotalMem), OFileUtils.getSizeAsString(freeSpaceInMB),
            OFileUtils.getSizeAsString(totalSpaceInMB)));
        return buffer.toString();
}


Instance 111

Class310.getJvmInfo()#5{
    long free = runtime.freeMemory();
    long max = runtime.maxMemory();
    long total = runtime.totalMemory();
}


Instance 112

Class680.test(String[] args)#13{
        long freeMax = rt.freeMemory();
        System.out.println("DEBUG: Free3: "+freeMax+", total: "+rt.totalMemory()+", max: "+rt.maxMemory());
}


Instance 113

Class50.onReceive(Container.StartupEvent event)#2{
                    appendInfo(
                            "info.memory.usage",
                            FileUtils.byteCountToDisplaySize((r.totalMemory() - r.freeMemory())),
                            FileUtils.byteCountToDisplaySize(r.maxMemory())
                    );
                    appendInfo("info.jmx.enabled", Messages.get("info.enabled." + isJmxEnabled()));
                    appendInfo("info.app.mode", Messages.get("info.app.mode." + getMode().name().toLowerCase()));
                            .append(Messages.get("info.locations"));
}


Instance 114

Class490.initOsmAndRoutingConfig(Builder config,final RouteCalculationParams params,OsmandSettings settings,GeneralRouter generalRouter)#4{
    log.warn("Use " + memoryLimit +  " MB Free " + rt.freeMemory() / mb + " of " + rt.totalMemory() / mb + " max " + rt.maxMemory() / mb);
}


Instance 115

Class480.eval(Sequence[] args,Sequence contextSequence)#0{
      memory = rt.maxMemory();
      memory = rt.totalMemory();
      memory = rt.freeMemory();
    return new IntegerValue(memory, Type.LONG);
}


Instance 116

Class470.dumpEnvironment()#4{
    buffer.append(String.format("OrientDB Memory profiler: Heap=%s of %s - DiskCache (%s dbs)=%s of %s - FS=%s of %s",
        OFileUtils.getSizeAsString(runtime.totalMemory() - runtime.freeMemory()), OFileUtils.getSizeAsString(runtime.maxMemory()),
        stgs, OFileUtils.getSizeAsString(diskCacheUsed), OFileUtils.getSizeAsString(diskCacheTotal),
        OFileUtils.getSizeAsString(freeSpaceInMB), OFileUtils.getSizeAsString(totalSpaceInMB)));
    return buffer.toString();
}


Instance 117

Class250.refresh()#5{
    this.vmStats.setLong(freeMemoryId, rt.freeMemory());
    this.vmStats.setLong(totalMemoryId, rt.totalMemory());
    this.vmStats.setLong(maxMemoryId, rt.maxMemory());
}


Instance 118

Class300.appendSystemInfo()#3{
        append("Free Memory: " + runtime.freeMemory() / 1024 / 1024 + "MB");
        append("Max Memory: " + runtime.maxMemory() / 1024 / 1024 + "MB");
        append("Total Memory: " + runtime.totalMemory() / 1024 / 1024 + "MB");
}


Instance 119

Class320.fillResponse(final HttpServletRequest req,final HttpServletResponse resp)#1{
        final Runtime runtime = Runtime.getRuntime();
        final double used_mem = runtime.totalMemory() / MB;
        final double max_mem = runtime.maxMemory() / MB;
        final double perc_mem = max_mem > 0 ?
                     used_mem / max_mem * 100.0 : 0.0;
        html.tableLine(new String[]
        {
            "Memory",
            String.format("%.1f MB of %.1f MB used (%.1f %%)",
                          used_mem, max_mem, perc_mem)
        });
        html.closeTable();
        html.close();
}


Instance 120

Class500.getMemoryInfo()#3{
      memoryInfo.append("Runtime free: ").append(kbString(run.freeMemory()))
            .append("\nRuntime max:").append(kbString(run.maxMemory()))
            .append("\nRuntime total:").append(kbString(run.totalMemory()));
}


Instance 121

Class50.createRuntimeProps(MemberStateImpl memberState)#4{
        map.put("memory.maxMemory", runtime.maxMemory());
        map.put("memory.freeMemory", runtime.freeMemory());
        map.put("memory.totalMemory", runtime.totalMemory());
}


Instance 122

Class720.memoryReportStr()#1{
    sb.append(numFmt.format(rt.totalMemory() / 1024.0));
    sb.append("Kb total, ");
    sb.append(numFmt.format(rt.freeMemory() / 1024.0));
    sb.append("Kb free, ");
    sb.append(numFmt.format(rt.maxMemory() / 1024.0));
    sb.append("Kb max.");
    return sb.toString();
}


Instance 123

Class250.serverInfo(CommandContext args,CommandSender sender)#1{
            sender.sendMessage(ChatColor.YELLOW + "Available processors: "
                    + rt.availableProcessors());
            sender.sendMessage(ChatColor.YELLOW + "Available total memory: "
                    + Math.floor(rt.maxMemory() / 1024.0 / 1024.0) + " MB");
            sender.sendMessage(ChatColor.YELLOW + "JVM allocated memory: "
                    + Math.floor(rt.totalMemory() / 1024.0 / 1024.0) + " MB");
            sender.sendMessage(ChatColor.YELLOW + "Free allocated memory: "
                    + Math.floor(rt.freeMemory() / 1024.0 / 1024.0) + " MB");
}


Instance 124

Class240.run(HttpSession ses)#1{
      _log.debug(
        "After GC: " +
          nf.format(runtime.freeMemory()) + " free, " +
            nf.format(runtime.totalMemory()) + " total, and " +
              nf.format(runtime.maxMemory()) + " max");
}


Instance 125

Class240.run(HttpSession ses)#0{
          nf.format(runtime.freeMemory()) + " free, " +
            nf.format(runtime.totalMemory()) + " total, and " +
              nf.format(runtime.maxMemory()) + " max");
      _log.debug("Running garbage collector");
}


Instance 126

Class200.run(HttpSession session)#1{
      _log.debug(
        "Before:\t\t" +
          nf.format(runtime.freeMemory()) + "\t" +
            nf.format(runtime.totalMemory()) + "\t" +
              nf.format(runtime.maxMemory()));
}


Instance 127

Class200.run(HttpSession session)#3{
      _log.debug(
        "After:\t\t" +
          nf.format(runtime.freeMemory()) + "\t" +
            nf.format(runtime.totalMemory()) + "\t" +
              nf.format(runtime.maxMemory()));
}


Instance 128

Class460.run(HttpServletRequest req,HttpServletResponse res)#0{
    String freeMemory = nf.format(runtime.freeMemory());
    String totalMemory = nf.format(runtime.totalMemory());
    String maxMemory = nf.format(runtime.maxMemory());
    _log.debug(
      "Memory Usage:\t" + freeMemory + "\t" + totalMemory + "\t" +
        maxMemory);
}


Instance 129

Class90.run(HttpServletRequest request,HttpServletResponse response)#1{
    String freeMemory = nf.format(runtime.freeMemory());
    String totalMemory = nf.format(runtime.totalMemory());
    String maxMemory = nf.format(runtime.maxMemory());
}


Instance 130

Class480.writeResponse(ManagementCenterService mcs,JsonObject root)#0{
        properties.add("memory.cl_freeMemory", Long.toString(runtime.freeMemory()));
        properties.add("memory.cl_totalMemory", Long.toString(runtime.totalMemory()));
        properties.add("memory.cl_maxMemory", Long.toString(runtime.maxMemory()));
}


Instance 131

Class70.getJvmInfo()#0{
    mem.add("free", humanReadableUnits(runtime.freeMemory(), df));
    mem.add("total", humanReadableUnits(runtime.totalMemory(), df));
    mem.add("max", humanReadableUnits(runtime.maxMemory(), df));
    mem.add("used", humanReadableUnits(used, df) + " (%" + df.format(percentUsed) + ")");
    jvm.add("memory", mem);
    SimpleOrderedMap<Object> jmx = new SimpleOrderedMap<Object>();
}


Instance 132

Class410.execute(JobExecutionContext jobExecutionContext)#0{
      m_datastore.putDataPoint("kairosdb.jvm.free_memory",
          tags, m_dataPointFactory.createDataPoint(timestamp, runtime.freeMemory()));
      m_datastore.putDataPoint("kairosdb.jvm.total_memory",
          tags, m_dataPointFactory.createDataPoint(timestamp, runtime.totalMemory()));
      m_datastore.putDataPoint("kairosdb.jvm.max_memory",
          tags, m_dataPointFactory.createDataPoint(timestamp, runtime.maxMemory()));
}


Instance 133

Class450.test()#1{
        logger.severe("maxMemory = " + runtime.maxMemory());
        logger.severe("freeMemory = " + runtime.freeMemory());
        logger.severe("totalMemory = " + runtime.totalMemory());
}


Instance 134

Class630.setup()#0{
        final Runtime runtime = Runtime.getRuntime();
        System.err.printf("Total Memory : "+PrintPrecision+" MiB%n", runtime.totalMemory() / MIB);
        System.err.printf("Max Memory   : "+PrintPrecision+" MiB%n", runtime.maxMemory() / MIB);
}


Instance 135

Class550.printAndLogVersion()#1{
    Runtime runtime = Runtime.getRuntime();
    Log.info ("Java availableProcessors: " + runtime.availableProcessors());
    Log.info ("Java heap totalMemory: " + String.format("%.2f gb", runtime.totalMemory() / ONE_GB));
    Log.info ("Java heap maxMemory: " + String.format("%.2f gb", runtime.maxMemory() / ONE_GB));
}


Instance 136

Class450.testSend()#3{
        Runtime runtime = Runtime.getRuntime();
        runtime.gc(); // i know, i know...
        long freeStart = runtime.freeMemory();
        long maxStart = runtime.maxMemory();
}


Instance 137

Class470.printAndLogVersion()#2{
    Runtime runtime = Runtime.getRuntime();
    Log.info("Java availableProcessors: " + runtime.availableProcessors());
    Log.info("Java heap totalMemory: " + PrettyPrint.bytes(runtime.totalMemory()));
    Log.info("Java heap maxMemory: " + PrettyPrint.bytes(runtime.maxMemory()));
}


Instance 138

Class140.printStatistics()#0{
            GridTcpDiscoveryNode coord = resolveCoordinator();
            log.info("Discovery SPI statistics [statistics=" + stats + ", spiState=" + spiStateCopy() +
                ", coord=" + coord +
                ", topSize=" + ring.allNodes().size() +
                ", leavingNodesSize=" + leavingNodesSize + ", failedNodesSize=" + failedNodesSize +
                ", msgWorker.queue.size=" + (msgWorker != null ? msgWorker.queue.size() : "N/A") +
                ", lastUpdate=" + (locNode != null ? U.format(locNode.lastUpdateTime()) : "N/A") +
                ", heapFree=" + runtime.freeMemory() / (1024 * 1024) +
                "M, heapTotal=" + runtime.maxMemory() / (1024 * 1024) + "M]");
}


Instance 139

Class340.logGCInfo(AccumuloConfiguration conf)#4{
      if (gcTimeIncreasedCount > 3 && mem < rt.maxMemory() * 0.05) {
        log.warn("Running low on memory");
        gcTimeIncreasedCount = 0;
      }
    if (mem != lastMemorySize) {
      sawChange = true;
    }
    if (mem - lastMemorySize <= 0) {
      sign = "";
    }
    sb.append(String.format(" freemem=%,d(%s%,d) totalmem=%,d", mem, sign, (mem - lastMemorySize), rt.totalMemory()));
}


Instance 140

Class700.availableHeapMemory(){
            Runtime runtime = runtime();
            return runtime.maxMemory() - runtime.totalMemory();
}


Instance 141

Class270.read()#1{
                logger.info(FORMAT.format(new Object[]{
                        new Long(sent), new Double(percent),
                        new Long(runtime.freeMemory()), new Long(runtime.maxMemory())}));
                        ((int) Math.floor(((double) size) / (messages - 1)) - 1);
}